
import pandas as pd
import io
import numpy as np
import matplotlib.pyplot as plt
import geopandas as gpd
import requests 
import folium
import json
from IPython.display import IFrame
import seaborn as sns
import plotly.io as pio


info1 = {'Colonne': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
              'Libellé': ['Code service', 'Référence document', 'Article CGI 1', 'Article CGI 2', 'Article CGI 3', 'Article CGI 4', 'Article CGI 5', 'N°de disposition', 'Date de mutation', 'Nature de la mutation'],
              'Descriptif': ['', '', '', '', '', '', '', 'Dans le cas des actes comprenant plusieurs mutations – appelées « dispositions » –, chacune d’entre elles est identifiée dans les fichiers par un numéro de disposition. Seules les dispositions concernant les mutations à titre onéreux sont restituées dans le fichier.', 'Date de signature de l’acte (au format JJ/MM/AAAA) – Une restitution au format AAAA/MM/JJ (norme ISO 8601) est prévue à compter de la mise à jour d’octobre 2019.', 'Vente, vente en l’état futur d’achèvement, vente de terrain à bâtir, adjudication, expropriation ou échange']
             }
info2 = {'Colonne': list(range(11, 44)),
              'Libellé': ['Valeur foncière', 'N° de voie', 'B/T/Q', 'Type de voie', 'Code voie', 'Voie', 'Code postal', 'Commune', 'Code département', 'Code commune', 'Préfixe de section', 'Section', 'N° de plan', 'N° de volume', '1er lot', 'Surface Carrez du 1er lot', '2e lot', 'Surface Carrez du 2e lot', '3e lot', 'Surface Carrez du 3e lot', '4e lot', 'Surface Carrez du 4e lot', '5e lot', 'Surface Carrez du 5e lot', 'Nombre de lots', 'Code type local', 'Type local', 'Identifiant local', 'Surface réelle bâti', 'Nombre de pièces principales', 'Code nature culture', 'Nature culture spéciale', 'Surface terrain'],
              'Descriptif': ['Il s’agit du montant ou de l’évaluation déclaré(e) dans le cadre d’une mutation à titre onéreux. La valeur foncière :\n• inclut :\n• les frais d’agence, s’ils sont à la charge du vendeur.\n• l’éventuelle TVA.\n• exclut :\n• les frais d’agence, s’ils sont à la charge de l’acquéreur.\n• les frais de notaires.\n• la valeur des biens meubles stipulée dans l’acte de mutation.', 'Numéro dans la voie', 'Indice de répétition', 'Exemple : Rue, avenue, etc.', 'Code Rivoli (répertoire informatisé codifiant, par commune, les voies, les lieux-dits et les ensembles immobiliers)', 'Libellé de la voie', '', 'Libellé de la commune', 'Référence cadastrale de la parcelle', 'Référence cadastrale de la parcelle', '', '', '', '', 'Un lot de copropriété est constitué d’une partie privative (appartement, cave, etc.) et d’une quote-part de partie commune (tantièmes). Seuls les 5 premiers lots sont mentionnés. Si le nombre de lots est supérieur à 5, ils ne sont pas restitués.', 'idem' , 'idem' ,'idem' , 'idem', 'idem', 'idem', 'idem', 'idem', 'idem', 'Nombre total de lots par disposition.', '1 : maison ; 2 : appartement ; 3 : dépendance (isolée) ; 4 : local industriel et commercial ou assimilés', "1 : maison ; 2 : appartement ; 3 : dépendance (isolée) ; 4 : local industriel et commercial ou assimilés", 'Donnée non restituée en application du décret n° 2018-1350 du 28 décembre 2018', 'la surface réelle est la surface mesurée au sol entre les murs ou séparations et arrondie au mètre carré inférieur. Les surfaces des dépendances ne sont pas prises en compte.',"les cuisines, salles d’eau et dépendances ne sont pas prises en compte.", "Voir dans le présente document la table de références « nature de culture »",'Voir dans le présent document la table de références « nature de culture spéciale »', ' Contenance du terrain']}
info1= pd.DataFrame(info1)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
info2= pd.DataFrame(info2)
info_concat = pd.concat([info1, info2])
styled_concat = info_concat .style.apply(lambda x: ['font-weight: bold' if i == 'fruit' else '' for i in x.index])

display (info_concat)


data18 = r'C:\Users\Jules\Documents\1_Cours\ESILV\A3\S2\Python\TD8_9\valeursfoncieres-2018.txt'
data19 = r'C:\Users\Jules\Documents\1_Cours\ESILV\A3\S2\Python\TD8_9\valeursfoncieres-2019.txt'
data20 = r'C:\Users\Jules\Documents\1_Cours\ESILV\A3\S2\Python\TD8_9\valeursfoncieres-2020.txt'
data21 = r'C:\Users\Jules\Documents\1_Cours\ESILV\A3\S2\Python\TD8_9\valeursfoncieres-2021.txt'
data22 = r'C:\Users\Jules\Documents\1_Cours\ESILV\A3\S2\Python\TD8_9\valeursfoncieres-2022.txt'


data18 = open(data18,'r')
data19 = open(data19,'r')
data20 = open(data20,'r')
data21 = open(data21,'r')
data22 = open(data22,'r')

column_dtypes = {column: 'str' for column in [14, 18, 23, 24, 26, 28, 29, 31, 32, 33, 41]}
df18 = pd.read_csv(data18, sep='|', dtype=column_dtypes, encoding='utf-8')
df19 = pd.read_csv(data19, sep='|', dtype=column_dtypes, encoding='utf-8')
df20 = pd.read_csv(data20, sep='|', dtype=column_dtypes, encoding='utf-8')
df21 = pd.read_csv(data21, sep='|', dtype=column_dtypes, encoding='utf-8')
df22 = pd.read_csv(data22, sep='|', dtype=column_dtypes, encoding='utf-8')

region = gpd.read_file('https://france-geojson.gregoiredavid.fr/repo/regions.geojson')
departements_geojson_url = "https://france-geojson.gregoiredavid.fr/repo/departements.geojson"
departements = gpd.read_file(departements_geojson_url)

C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\760797934.py:18: DtypeWarning: Columns (30) have mixed types. Specify dtype option on import or set low_memory=False.
  df21 = pd.read_csv(data21, sep='|', dtype=column_dtypes, encoding='utf-8')


def nettoyage_de_données(df) :

    #conversion des surfaces et prix en float

    if df['Surface Carrez du 1er lot'].dtype == 'object':
        df.loc[:, 'Surface Carrez du 1er lot'] = df['Surface Carrez du 1er lot'].str.replace(',', '.').astype(float)

    if df['Valeur fonciere'].dtype == 'object':
        df.loc[:, 'Valeur fonciere'] = df['Valeur fonciere'].str.replace(',', '.').astype(float)

    for i in range(2, 6):
        zen = str(i) + 'eme lot'
        
        col_name = 'Surface Carrez du ' + zen
        if df[col_name].dtype == 'object':
            df.loc[:, col_name] = df[col_name].str.replace(',', '.').astype(float)

    if df['Surface reelle bati'].dtype == 'object':
        df.loc[:, 'Surface reelle bati'] = df['Surface reelle bati'].str.replace(',', '.').astype(float)


    df['Code departement'] = df['Code departement'].astype(str)

    df['Code postal'] = df['Code postal'].astype(str)

    #Nettoyage des données :  2eme partie 

    # Supprimer les lignes avec des données manquantes ou aberrantes
    df = df.dropna(subset=['Date mutation', 'Nature mutation', 'Valeur fonciere', 'Code postal', 'Code departement', 'Commune', 'Type local', 'Surface reelle bati', 'Nombre pieces principales'])

    # Supprimer les lignes avec des valeurs aberrantes (par exemple, valeur foncière ou surface reelle bati égale à 0)
    df= df[(df['Valeur fonciere'] > 0) & (df['Surface reelle bati'] > 0)]

    # Créer une nouvelle colonne 'Prix m2'
    df['Prix m2'] = df['Valeur fonciere'] / df['Surface reelle bati']

    # Réinitialiser les index
    df.reset_index(drop=True, inplace=True)

    # Calcul de l'IQR
    Q1 = df['Prix m2'].quantile(0.13)
    Q3 = df['Prix m2'].quantile(0.87)
    IQR = Q3 - Q1

    # Définir les limites pour les valeurs extrêmes
    lower_bound = Q1 - 1.5 * IQR
    upper_bound = Q3 + 1.5 * IQR

    # Filtrer les valeurs extrêmes
    df = df[(df['Prix m2'] >= lower_bound) & (df['Prix m2'] <= upper_bound)]

    # Réinitialiser les index
    df.reset_index(drop=True, inplace=True)
    return df

df18 = nettoyage_de_données(df18)
df19 = nettoyage_de_données(df19)
df20 = nettoyage_de_données(df20)
df21 = nettoyage_de_données(df21)
df22 = nettoyage_de_données(df22)

C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:6: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, 'Surface Carrez du 1er lot'] = df['Surface Carrez du 1er lot'].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:9: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, 'Valeur fonciere'] = df['Valeur fonciere'].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:16: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, col_name] = df[col_name].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:6: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, 'Surface Carrez du 1er lot'] = df['Surface Carrez du 1er lot'].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:9: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, 'Valeur fonciere'] = df['Valeur fonciere'].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:16: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, col_name] = df[col_name].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:6: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, 'Surface Carrez du 1er lot'] = df['Surface Carrez du 1er lot'].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:9: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, 'Valeur fonciere'] = df['Valeur fonciere'].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:16: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, col_name] = df[col_name].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:6: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, 'Surface Carrez du 1er lot'] = df['Surface Carrez du 1er lot'].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:9: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, 'Valeur fonciere'] = df['Valeur fonciere'].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:16: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, col_name] = df[col_name].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:6: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, 'Surface Carrez du 1er lot'] = df['Surface Carrez du 1er lot'].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:9: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, 'Valeur fonciere'] = df['Valeur fonciere'].str.replace(',', '.').astype(float)
C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\625249364.py:16: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`
  df.loc[:, col_name] = df[col_name].str.replace(',', '.').astype(float)


#correspondance code region ----> nom region

dico_region = {
    '01': "Guadeloupe",
    '02': "Martinique",
    '03': "Guyane",
    '04': "La Réunion",
    '06': "Mayotte",
    '11': "Île-de-France",
    '24': "Centre-Val de Loire",
    '27': "Bourgogne-Franche-Comté",
    '28': "Normandie",
    '32': "Hauts-de-France",
    '44': "Grand Est",
    '52': "Pays de la Loire",
    '53': "Bretagne",
    '75': "Nouvelle-Aquitaine",
    '76': "Occitanie",
    '84': "Auvergne-Rhône-Alpes",
    '93': "Provence-Alpes-Côte d'Azur",
    '94': "Corse"
}

#correspondance code departement ----> nom departement

dico_departements = {
    '01': 'Ain', 
    '02': 'Aisne', 
    '03': 'Allier', 
    '04': 'Alpes-de-Haute-Provence', 
    '05': 'Hautes-Alpes',
    '06': 'Alpes-Maritimes', 
    '07': 'Ardèche', 
    '08': 'Ardennes', 
    '09': 'Ariège', 
    '10': 'Aube', 
    '11': 'Aude',
    '12': 'Aveyron', 
    '13': 'Bouches-du-Rhône', 
    '14': 'Calvados', 
    '15': 'Cantal', 
    '16': 'Charente',
    '17': 'Charente-Maritime', 
    '18': 'Cher', 
    '19': 'Corrèze', 
    '2A': 'Corse-du-Sud', 
    '2B': 'Haute-Corse',
    '21': 'Côte-d\'Or', 
    '22': 'Côtes-d\'Armor', 
    '23': 'Creuse', 
    '24': 'Dordogne', 
    '25': 'Doubs', 
    '26': 'Drôme',
    '27': 'Eure', 
    '28': 'Eure-et-Loir', 
    '29': 'Finistère', 
    '30': 'Gard', 
    '31': 'Haute-Garonne', 
    '32': 'Gers',
    '33': 'Gironde', 
    '34': 'Hérault', 
    '35': 'Ille-et-Vilaine', 
    '36': 'Indre', 
    '37': 'Indre-et-Loire',
    '38': 'Isère', 
    '39': 'Jura', 
    '40': 'Landes', 
    '41': 'Loir-et-Cher', 
    '42': 'Loire', 
    '43': 'Haute-Loire',
    '44': 'Loire-Atlantique', 
    '45': 'Loiret', 
    '46': 'Lot', 
    '47': 'Lot-et-Garonne', 
    '48': 'Lozère',
    '49': 'Maine-et-Loire', 
    '50': 'Manche', 
    '51': 'Marne', 
    '52': 'Haute-Marne', 
    '53': 'Mayenne',
    '54': 'Meurthe-et-Moselle', 
    '55': 'Meuse', 
    '56': 'Morbihan', 
    '57': 'Moselle', 
    '58': 'Nièvre', 
    '59': 'Nord',
    '60': 'Oise', 
    '61': 'Orne', 
    '62': 'Pas-de-Calais', 
    '63': 'Puy-de-Dôme', 
    '64': 'Pyrénées-Atlantiques',
    '65': 'Hautes-Pyrénées', 
    '66': 'Pyrénées-Orientales', 
    '67': 'Bas-Rhin', 
    '68': 'Haut-Rhin', 
    '69': 'Rhône',
    '70': 'Haute-Saône', 
    '71': 'Saône-et-Loire', 
    '72': 'Sarthe', 
    '73': 'Savoie', 
    '74': 'Haute-Savoie',
    '75': 'Paris', 
    '76': 'Seine-Maritime', 
    '77': 'Seine-et-Marne', 
    '78': 'Yvelines', 
    '79': 'Deux-Sèvres',
    '80': 'Somme', 
    '81': 'Tarn', 
    '82': 'Tarn-et-Garonne', 
    '83': 'Var', 
    '84': 'Vaucluse', 
    '85': 'Vendée',
    '86': 'Vienne', 
    '87': 'Haute-Vienne', 
    '88': 'Vosges', 
    '89': 'Yonne', 
    '90': 'Territoire de Belfort',
    '91': 'Essonne', 
    '92': 'Hauts-de-Seine', 
    '93': 'Seine-Saint-Denis', 
    '94': 'Val-de-Marne', 
    '95': 'Val-d\'Oise',
    '971': 'Guadeloupe', 
    '972': 'Martinique', 
    '973': 'Guyane', 
    '974': 'La Réunion', 
    '976': 'Mayotte',
}

mes_datas_frames = [df18, df19, df20, df21, df22]
années = [2018, 2019, 2020, 2021, 2022]

#correspondance code departement ----> code region


departements_regions = dict ({
    '01': '84',  # Ain
    '02': '32',  # Aisne
    '03': '84',  # Allier
    '04': '93',  # Alpes-de-Haute-Provence
    '05': '93',  # Hautes-Alpes
    '06': '93',  # Alpes-Maritimes
    '07': '84',  # Ardèche
    '08': '44',  # Ardennes
    '09': '76',  # Ariège
    '10': '44',  # Aube
    '11': '76',  # Aude
    '12': '76',  # Aveyron
    '13': '93',  # Bouches-du-Rhône
    '14': '28',  # Calvados
    '15': '84',  # Cantal
    '16': '75',  # Charente
    '17': '75',  # Charente-Maritime
    '18': '24',  # Cher
    '19': '75',  # Corrèze
    '21': '27',  # Côte-d'Or
    '22': '53',  # Côtes-d'Armor
    '23': '75',  # Creuse
    '24': '75',  # Dordogne
    '25': '27',  # Doubs
    '26': '84',  # Drôme
    '27': '28',  # Eure
    '28': '24',  # Eure-et-Loir
    '29': '53',  # Finistère
    '2A': '94',  # Corse-du-Sud
    '2B': '94',  # Haute-Corse
    '30': '76',  # Gard
    '31': '76',  # Haute-Garonne
    '32': '76',  # Gers
    '33': '75',  # Gironde
    '34': '76',  # Hérault
    '35': '53',  # Ille-et-Vilaine
    '36': '24',  # Indre
    '37': '24',  # Indre-et-Loire
    '38': '84',  # Isère
    '39': '27',  # Jura
    '40': '75',  # Landes
    '41': '24',  # Loir-et-Cher
    '42': '84',  # Loire
    '43': '84',  # Haute-Loire
    '44': '52',  # Loire-Atlantique
    '45': '24',  # Loiret
    '46': '76',  # Lot
    '47': '75',  # Lot-et-Garonne
    '48': '76',  # Lozère
    '49': '52',  # Maine-et-Loire
    '50': '28',  # Manche
    '51': '44',  # Marne
    '52': '44',  # Haute-Marne
    '53': '52',  # Mayenne
    '54': '44',  # Meurthe-et-Moselle
    '55': '44',  # Meuse
    '56': '53',  # Morbihan
    '57': '44',  # Moselle
    '58': '27',  # Nièvre
    '59': '32',  # Nord
    '60': '32',  # Oise
    '61': '28',  # Orne
    '62': '32',  # Pas-de-Calais
    '63': '84',  # Puy-de-Dôme
    '64': '75',  # Pyrénées-Atlantiques
    '65': '76',  # Hautes-Pyrénées
    '66': '76',  # Pyrénées-Orientales
    '67': '44',  # Bas-Rhin
    '68': '44',  # Haut-Rhin
    '69': '84',  # Rhône
    '70': '27',  # Haute-Saône
    '71': '27',  # Saône-et-Loire
    '72': '52',  # Sarthe
    '73': '84',  # Savoie
    '74': '84',  # Haute-Savoie
    '75': '11',  # Paris
    '76': '28',  # Seine-Maritime
    '77': '11',  # Seine-et-Marne
    '78': '11',  # Yvelines
    '79': '75',  # Deux-Sèvres
    '80': '32',  # Somme
    '81': '76',  # Tarn
    '82': '76',  # Tarn-et-Garonne
    '83': '93',  # Var
    '84': '93',  # Vaucluse
    '85': '52',  # Vendée
    '86': '75',  # Vienne
    '87': '75',  # Haute-Vienne
    '88': '44',  # Vosges
    '89': '27',  # Yonne
    '90': '27',  # Territoire de Belfort
    '91': '11',  # Essonne
    '92': '11',  # Hauts-de-Seine
    '93': '11',  # Seine-Saint-Denis
    '94': '11',  # Val-de-Marne
    '95': '11',  # Val-d'Oise
})


# Chargez les fichiers GeoJSON des départements et des régions
gdf_departements = gpd.read_file("https://raw.githubusercontent.com/gregoiredavid/france-geojson/master/departements-version-simplifiee.geojson")
gdf_regions = gpd.read_file("https://raw.githubusercontent.com/gregoiredavid/france-geojson/master/regions-version-simplifiee.geojson")

grouped_by_region = {}
i= 18



df18['Code region'] = df18['Code departement'].map(departements_regions)
df18['Nom region'] = df18['Code region'].map(dico_region)
df18['Nom departement'] = df18['Code departement'].map(dico_departements)

df19['Code region'] = df19['Code departement'].map(departements_regions)
df19['Nom region'] = df19['Code region'].map(dico_region)
df19['Nom departement'] = df19['Code departement'].map(dico_departements)

df20['Code region'] = df20['Code departement'].map(departements_regions)
df20['Nom region'] = df20['Code region'].map(dico_region)
df20['Nom departement'] = df20['Code departement'].map(dico_departements)

df21['Code region'] = df21['Code departement'].map(departements_regions)
df21['Nom region'] = df21['Code region'].map(dico_region)
df21['Nom departement'] = df21['Code departement'].map(dico_departements)

df22['Code region'] = df22['Code departement'].map(departements_regions)
df22['Nom region'] = df22['Code region'].map(dico_region)
df22['Nom departement'] = df22['Code departement'].map(dico_departements)

for df in mes_datas_frames :
    df['Code region'] = df['Code departement'].map(departements_regions)
    df = df.merge(gdf_regions[['code', 'nom']], left_on='Code region', right_on='code', how='left')
    df.drop(columns=['code'], inplace=True)

    grouped_by_region[f"df20{i}"] = df.groupby('Nom region').agg({'Valeur fonciere': 'sum', 'Surface terrain': 'sum', 'Prix m2': 'mean'})
    
    i +=1


#Ici il faut choisir les variables type_local parmis : 
# 'Maison','Appartement', 'Dépendance', 'Local industriel. commercial ou assimilé'
def comparaison_type_local(année, type_local1, type_local2) : 
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    # Filtrer les données pour les appartements et les maisons
    appartements = df[df['Type local'] == type_local1]
    maisons = df[df['Type local'] == type_local2 ]

    # Créer l'histogramme
    plt.figure(figsize=(12, 6))

    # Utiliser le 95e percentile comme valeur maximale pour les intervalles
    max_value = df['Valeur fonciere'].quantile(0.95)
    bins = np.arange(0, max_value + 5000, 5000)

    plt.hist(appartements['Valeur fonciere'], bins=bins, alpha=0.7, color='blue', label=type_local1, rwidth=0.85)
    plt.hist(maisons['Valeur fonciere'], bins=bins, alpha=0.7, color='red', label=type_local2, rwidth=0.85)

    # Ajouter la légende et les étiquettes
    plt.legend()
    plt.xlabel('Valeur fonciere')
    plt.ylabel('Nombre de transactions')
    plt.title(f"Nombre de transactions en fonction de la 'Valeur fonciere' pour les {type_local1}s et les {type_local2}s en {année}")

    # Sauvegarder le graphique dans un fichier image (par exemple, au format PNG)
    plt.savefig(f'transactions_valeur_fonciere_{type_local1}_{type_local2}_{année}.png', dpi=300, bbox_inches='tight')

    # Afficher le graphique
    plt.show()


types_locaux = ['Maison','Appartement', 'Dépendance' 'Local industriel. commercial ou assimilé']
for type_local1 in types_locaux :
    for type_local2 in  types_locaux :
        if type_local1 != type_local2 :
            comparaison_type_local(2022, type_local1, type_local2)


def plot_histogram(année):
    # on choisit le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22


    # On crée l'histogramme
    plt.figure(figsize=(10, 6))
    
    # on utilise le 95e percentile comme valeur maximale pour les intervalles
    max_value = df['Valeur fonciere'].quantile(0.95)
    bins = np.arange(0, max_value + 5000, 5000)
    
    plt.hist(df['Valeur fonciere'], bins=bins)
    plt.xlabel('Valeur Foncière')
    plt.ylabel('Fréquence')
    plt.title(f'Distribution de la valeur foncière pour {année}')
    plt.grid(True)
    plt.show()


plot_histogram(2022)


def transaction_Région_heatmap(année):

    # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    transactions_par_region = df.groupby('Code region').size().reset_index(name='Nombre de transactions')

    # chargement des datas geojson pour les régions 
    url_regions_geojson = 'https://raw.githubusercontent.com/gregoiredavid/france-geojson/master/regions-version-simplifiee.geojson'
    regions_geojson = json.loads(requests.get(url_regions_geojson).text)

    # Création d'une map centrée sur la france 
    map = folium.Map(location=[46.603354, 1.888334], zoom_start=6)

    # créations d'un dico de transaction par région 
    transactions_dict = transactions_par_region.set_index('Code region')['Nombre de transactions']

    # fonction pour avoir les transactions par régions 
    def get_transactions(code_region):
        return transactions_dict.get(str(code_region), 'Données non disponibles')

    # Création d'un Choropleth avec les données et le survol de souris 
    folium.Choropleth(
        geo_data=regions_geojson,
        name='choropleth',
        data=transactions_par_region,
        columns=['Code region', 'Nombre de transactions'],
        key_on='feature.properties.code',
        fill_color='Oranges',
        fill_opacity=0.7,
        line_opacity=0.8,
        legend_name=f'Nombre de transactions par région en {année}',
        title = 'Nombre de transactions par région'
    ).add_to(map)

    # ajout d'infos quand la souris survole une zone 
    info_layer = folium.GeoJson(
        regions_geojson,
        style_function=lambda x: {'fillColor': '#ffffff', 'color': '#000000', 'fillOpacity': 0.1, 'weight': 0.1},
        tooltip=folium.GeoJsonTooltip(fields=['nom', 'code'],
                                    aliases=['Région :', 'Code :'],
                                    labels=True,
                                    sticky=False),
        highlight_function=lambda x: {'weight': 3, 'fillOpacity': 0.6}
    ).add_to(map)

    # affichage de la carte 
    display(map)
    map.save(f"C:\\Users\\Jules\\Documents\\1_Cours\\ESILV\\A3\\S2\\Python\\TD8_9\\affichage\\affichage\\templates\\Nb_transac_par_region_{année}.html")
    #je dois utiliser soit  des doubles backslashes (\\), soit utiliser des slashes normaux (/), car un seul backslash est interprété comme un caractère d'échappement.

transaction_Région_heatmap(2022)


def plot_boxplot(année):
    # choix du dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    # Création d boxplot
    plt.figure(figsize=(10, 6))
    df.boxplot(column='Valeur fonciere', by='Type local', grid=False, showfliers=False)
    plt.title(f'Répartition de la Valeur Foncière par Type Local pour {année}')
    plt.suptitle('')  # Supprime le titre automatiquement généré
    plt.ylabel('Valeur Foncière')
    plt.xticks(rotation=90)
    plt.show()

plot_boxplot(2022)

<Figure size 1000x600 with 0 Axes>


def transaction_dep(année) :

     # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22



    transactions_par_departement = df.groupby('Code departement').size().reset_index(name='Nombre de transactions')
    transactions_par_region = df.groupby('Code region').size().reset_index(name='Nombre de transactions')

    # Load GeoJSON data for departments
    url_departements_geojson = 'https://france-geojson.gregoiredavid.fr/repo/departements.geojson'
    departements_geojson = json.loads(requests.get(url_departements_geojson).text)

    # Create a map centered on France
    map = folium.Map(location=[46.603354, 1.888334], zoom_start=6)

    # Create a dictionary of transactions by department
    transactions_dict = transactions_par_departement.set_index('Code departement')['Nombre de transactions']

    # Function to get transactions for a given department
    def get_transactions(code_departement):
        return transactions_dict.get(str(code_departement), 'Données non disponibles')

    # Create a Choropleth with transactions by department and add mouse hover
    folium.Choropleth(
        geo_data=departements_geojson,
        name='choropleth',
        data=transactions_par_departement,
        columns=['Code departement', 'Nombre de transactions'],
        key_on='feature.properties.code',
        fill_color='Oranges',
        fill_opacity=0.7,
        line_opacity=0.8,
        legend_name=f'Nombre de transactions par département en {année}',
        title = 'Nombre de transaction par département'
    ).add_to(map)

    # Add an info layer on hover
    info_layer = folium.GeoJson(
        departements_geojson,
        style_function=lambda x: {'fillColor': '#ffffff', 'color': '#000000', 'fillOpacity': 0.1, 'weight': 0.1},
        tooltip=folium.GeoJsonTooltip(fields=['nom', 'code',],
                                    aliases=['Département :', 'Code :'],
                                    labels=True,
                                    sticky=False),
        highlight_function=lambda x: {'weight': 3, 'fillOpacity': 0.6}
    ).add_to(map)

    # Display the map
    display(map)
    map.save(f"C:\\Users\\Jules\\Documents\\1_Cours\\ESILV\\A3\\S2\\Python\\TD8_9\\affichage\\affichage\\templates\\Nb_transac_par_departement_{année}.html")


transaction_dep(2022)


def repartition_prix_m2(année) :

     # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    # Récupérer les prix au m² dans une variable
    prix_m2 = df['Prix m2']

    # Calculer les quartiles
    quartiles = prix_m2.quantile([0.25, 0.5, 0.75])

    # Créer l'histogramme
    fig, ax = plt.subplots(figsize=(12, 6))
    ax.hist(prix_m2, bins=50, color='blue', alpha=0.7, rwidth=0.85)

    # Ajouter les lignes verticales pour les quartiles
    ax.axvline(quartiles[0.25], color='green', linestyle='dashed', linewidth=2, label=f"Q1: {quartiles[0.25]:.2f}")
    ax.axvline(quartiles[0.5], color='red', linestyle='dashed', linewidth=2, label=f"Q2 (médiane): {quartiles[0.5]:.2f}")
    ax.axvline(quartiles[0.75], color='orange', linestyle='dashed', linewidth=2, label=f"Q3: {quartiles[0.75]:.2f}")

    # Ajouter la légende et les étiquettes
    ax.legend()
    ax.set_xlabel('Prix au m²')
    ax.set_ylabel('Nombre de transactions')
    ax.set_title(f'Distribution du prix au m² en France en {année}')
    

    # Définir les limites d'axes personnalisées
    ax.set_xlim(0, 9000)  # Remplacez xmin et xmax par les valeurs de début et de fin souhaitées pour l'axe x

    # Afficher le graphique
    plt.show()
    plt.savefig(f'C:\\Users\\Jules\\Documents\\1_Cours\\ESILV\\A3\\S2\\Python\\TD8_9\\affichage\\affichage\\templates\\Distribution_du_prix_au_m²_en_France_en_{année}.png', dpi=300, bbox_inches='tight')
    
repartition_prix_m2(2022)

<Figure size 640x480 with 0 Axes>


def afficher_prix_m2_commune(nom_commune, année):
     # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22
    nom_commune = nom_commune.lower()
    
    if nom_commune == 'paris':
        arrondissements = [' 01', ' 02', ' 03', ' 04', ' 05', ' 06',  ' 07', ' 08', ' 09 ', ' 10' , ' 11', ' 12', ' 13', ' 14', ' 15', ' 16', ' 17', ' 18', ' 19', ' 20']
        commune_data = df[df['Commune'].str.lower().str.startswith(nom_commune) & df['Commune'].str.contains('|'.join(arrondissements))]
    # Filtrer le DataFrame pour la commune spécifiée
    commune_data = df[df['Commune'].str.lower().str.startswith(nom_commune)]
    #la ligne du dessus permet de gérer le cas de Paris
    commune_data = commune_data.dropna(subset=['Valeur fonciere', 'Surface terrain', 'Surface reelle bati'])

    # Filtrer les données avec des valeurs supérieures à 0 pour 'Valeur fonciere' et 'Surface reelle bati'
    commune_data = commune_data[(commune_data['Valeur fonciere'] > 10) & (commune_data['Surface reelle bati'] > 2)]
    commune_data = commune_data[(commune_data['Code type local'] == 2) | (commune_data['Code type local'] == 1) ]
    
    # Calculer le prix moyen du m2 pour la commune
    commune_data['Prix m2'] = commune_data['Valeur fonciere'] / commune_data['Surface reelle bati']
    
    # Filtrer les données pour conserver uniquement celles qui sont inférieures au 90e percentile
    percentile_90 = commune_data['Prix m2'].quantile(0.90)
    commune_data = commune_data[commune_data['Prix m2'] <= percentile_90]
    
    # Calculer le prix moyen du m2 pour la commune après filtrage
    prix_m2_moyen = commune_data['Prix m2'].mean()

    # Obtenir les coordonnées de la commune
    url = f"https://api-adresse.data.gouv.fr/search/?q={nom_commune}&limit=1"
    response = requests.get(url)
    data = response.json()
    coords = data['features'][0]['geometry']['coordinates'][::-1]

    # Créer une carte centrée sur la commune
    m = folium.Map(location=coords, zoom_start=13)

    # Ajouter un marqueur avec le prix moyen du m2
    folium.Marker(
        location=coords,
        popup=f"Prix moyen du m2 pour {nom_commune}: {prix_m2_moyen:.2f} €",
        icon=folium.Icon(color='blue')
    ).add_to(m)
    display (m)
    m.save(f"C:\\Users\\Jules\Documents\\1_Cours\ESILV\A3\S2\Python\TD8_9\\affichage\\affichage\\templates\\Prix_{nom_commune}.html")


# Exemple d'utilisation de la fonction
carte = afficher_prix_m2_commune("Paris ", 2022) 
carte = afficher_prix_m2_commune("Nice", 2022)
carte = afficher_prix_m2_commune("Lyon", 2022)
carte = afficher_prix_m2_commune("Marseille ", 2022)


Paris = df22[df22['Commune'].str.lower().str.startswith('paris')]
display(Paris['Commune'])

795319     PARIS-L HOPITAL
796182     PARIS-L HOPITAL
798087     PARIS-L HOPITAL
938537             PARISOT
938657             PARISOT
                ...       
1200201           PARIS 15
1200202           PARIS 16
1200203           PARIS 15
1200204           PARIS 14
1200205           PARIS 15
Name: Commune, Length: 39823, dtype: object


import datetime
import plotly.graph_objs as go
import plotly.io as pio
def valeur_fonciere_mediane(année): 
     # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22
    # Convert the 'Date de mutation' column to datetime data type
    df['Date mutation'] = pd.to_datetime(df['Date mutation'])

    # Calculate the month for each 'Date de mutation'
    df['Mois'] = df['Date mutation'].apply(lambda x: x.strftime('%Y-%m'))

    # Group data by month and calculate the median of 'Valeur foncière' for each month
    valeur_fonciere_par_mois = df.groupby('Mois')['Valeur fonciere'].median().reset_index()

    # Sort the DataFrame by month
    valeur_fonciere_par_mois = valeur_fonciere_par_mois.sort_values('Mois')

    # Convert the month number to month name
    valeur_fonciere_par_mois['Mois'] = valeur_fonciere_par_mois['Mois'].apply(lambda x: datetime.datetime.strptime(x, '%Y-%m').strftime('%Y-%B'))

    # Create a bar chart using Plotly
    fig = go.Figure(go.Bar(x=valeur_fonciere_par_mois['Mois'], y=valeur_fonciere_par_mois['Valeur fonciere'], marker=dict(color=valeur_fonciere_par_mois['Valeur fonciere'], colorscale='Viridis')))

    # Set the title and axis labels
    fig.update_layout(title="Évolution de la 'Valeur foncière' médiane en fonction du mois", xaxis_title='Mois', yaxis_title='Valeur fonciere médiane')

    # Save the figure as an interactive HTML file
    display (fig)
    pio.write_html(fig, file=f'C:\\Users\\Jules\\Documents\\1_Cours\\ESILV\\A3\\S2\\Python\\TD8_9\\affichage\\affichage\\templates\\graphique_valeur_fonciere_mediane_{année}.html', auto_open=True)

valeur_fonciere_mediane(2022)



def valeur_fonciere_moyenne(année): 
     # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22
    # Convert the 'Date de mutation' column to datetime data type
    df['Date mutation'] = pd.to_datetime(df['Date mutation'])

    # Calculate the month for each 'Date de mutation'
    df['Mois'] = df['Date mutation'].apply(lambda x: x.strftime('%Y-%m'))

    # Group data by month and calculate the median of 'Valeur foncière' for each month
    valeur_fonciere_par_mois = df.groupby('Mois')['Valeur fonciere'].mean().reset_index()

    # Sort the DataFrame by month
    valeur_fonciere_par_mois = valeur_fonciere_par_mois.sort_values('Mois')

    # Convert the month number to month name
    valeur_fonciere_par_mois['Mois'] = valeur_fonciere_par_mois['Mois'].apply(lambda x: datetime.datetime.strptime(x, '%Y-%m').strftime('%Y-%B'))

    # Create a bar chart using Plotly
    fig = go.Figure(go.Bar(x=valeur_fonciere_par_mois['Mois'], y=valeur_fonciere_par_mois['Valeur fonciere'], marker=dict(color=valeur_fonciere_par_mois['Valeur fonciere'], colorscale='Viridis')))

    # Set the title and axis labels
    fig.update_layout(title="Évolution de la 'Valeur foncière' médiane en fonction du mois", xaxis_title='Mois', yaxis_title='Valeur fonciere médiane')

    # Save the figure as an interactive HTML file
    display (fig)
    pio.write_html(fig, file=f'C:\\Users\\Jules\\Documents\\1_Cours\\ESILV\\A3\\S2\\Python\\TD8_9\\affichage\\affichage\\templates\\graphique_valeur_fonciere_moyenne_{année}.html', auto_open=True)

valeur_fonciere_moyenne(2022)

C:\Users\Jules\AppData\Local\Temp\ipykernel_15292\2373932991.py:17: UserWarning: Parsing dates in DD/MM/YYYY format when dayfirst=False (the default) was specified. This may lead to inconsistently parsed dates! Specify a format to ensure consistent parsing.
  df['Date mutation'] = pd.to_datetime(df['Date mutation'])


def plot_bar_chart(année):
    # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    # Comptez la fréquence de chaque type de transaction
    mutation_counts = df['Nature mutation'].value_counts()

    # Créez le diagramme à barres
    plt.figure(figsize=(10, 6))
    plt.bar(mutation_counts.index, mutation_counts.values, alpha=0.75, log=True)  # Ajouter l'échelle logarithmique
    plt.xlabel('Nature de la Mutation')
    plt.ylabel('Fréquence (log scale)')
    plt.title(f'Fréquence de chaque Type de Transaction pour {année} (échelle logarithmique)')
    plt.xticks(rotation=90)
    plt.legend()
    plt.show()
    plt.savefig(f'C:\\Users\\Jules\\Documents\\1_Cours\\ESILV\\A3\\S2\\Python\\TD8_9\\affichage\\affichage\\templates\\Fréquence_de_chaque_Type_de_Transaction_pour_{année}_(log).png', dpi=300, bbox_inches='tight')

def plot_pie_chart(année):
    # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    # Comptez la fréquence de chaque type de transaction
    mutation_counts = df['Nature mutation'].value_counts()

    # Créez le diagramme en camembert
    plt.figure(figsize=(10, 6)) 
    plt.pie(mutation_counts.values, autopct='%1.1f%%') 
    plt.title(f'Fréquence de chaque Type de Transaction pour {année}')
    plt.legend(labels = mutation_counts.index)
    plt.show()
    plt.savefig(f'C:\\Users\\Jules\\Documents\\1_Cours\\ESILV\\A3\\S2\\Python\\TD8_9\\affichage\\affichage\\templates\\Fréquence_de_chaque_Type_de_Transaction_pour_{année}.png', dpi=300, bbox_inches='tight')
          


plot_bar_chart (2022)
plot_pie_chart(2022)

No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.

<Figure size 640x480 with 0 Axes>

<Figure size 640x480 with 0 Axes>


def nb_pièces_principales(année):
    # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22


    plt.figure(figsize=(10,6))
    plt.hist(df['Nombre pieces principales'], bins=90, color='skyblue', edgecolor='black')
    plt.xlabel('Nombre de pièces principales')
    plt.ylabel('Fréquence')
    plt.title('Distribution du nombre de pièces principales')
    plt.grid(True)
    plt.xlim(0,12)
    plt.show()

nb_pièces_principales(2022)


def nb_transaction_code_postal(année):
    # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    postal_counts = df['Code postal'].value_counts().head(10)
    plt.figure(figsize=(10,6))
    sns.barplot(x=postal_counts.index, y=postal_counts.values, palette='viridis')
    plt.xlabel('Code postal')
    plt.ylabel('Nombre de transactions')
    plt.title(f'Nombre de transactions par code postal en {année}')
    plt.xticks(rotation=90)
    plt.show()

nb_transaction_code_postal(2022)


def nb_pièces_principales_type_local(année):
    # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22
    df = df[df['Type local'].isin(['Maison', 'Appartement'])]
    plt.figure(figsize=(10,6))
    sns.boxplot(x='Type local', y='Nombre pieces principales', data=df)
    plt.xlabel('Type local')
    plt.ylabel('Nombre de pièces principales')
    plt.title('Distribution du nombre de pièces principales par type local')
    plt.xticks(rotation=90)
    plt.show()
nb_pièces_principales_type_local(2022)


def nature_mutation_type_local(année):
    # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22
    # Créer une table pivot pour le diagramme à barres empilé
    pivot_df = df.pivot_table(index='Nature mutation', columns='Type local', aggfunc='size', fill_value=0)

    # Créer le diagramme à barres empilé
    pivot_df.plot(kind='bar', stacked=True, figsize=(10,7))
    plt.ylabel('Nombre de transactions')
    plt.title(f'Transactions par Nature de la mutation et Type local en {année}')
    
    # Définir l'échelle logarithmique sur l'axe y
    plt.yscale('log')
    
    plt.show()

nature_mutation_type_local(2022)


def distribution_prix_m2(année):
    # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    # Créer l'histogramme
    plt.figure(figsize=(10,7))
    plt.hist(df['Prix m2'], bins=50, color='skyblue', edgecolor='black')
    plt.xlabel('Prix du m2')
    plt.ylabel('Fréquence')
    plt.title(f'Distribution du Prix du m2 en {année}')
    plt.show()

distribution_prix_m2(2022)


def prix_m2_nb_pieces_principales(année):
    # Choix du dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    # Céation du diagramme de dispersion avec une légende pour la couleur
    plt.figure(figsize=(10,7))
    scatter = plt.scatter(df['Nombre pieces principales'], df['Prix m2'], alpha=0.5, c=df['Code type local'], cmap='viridis')
    plt.xlabel('Nombre de pièces principales')
    plt.ylabel('Prix du m2')
    plt.title(f'Prix du m2 contre Nombre de pièces principales en {année}')
    
    # Ajout de  la légende
    cbar = plt.colorbar(scatter)
    cbar.set_label('Code type local')
    
    plt.show()

prix_m2_nb_pieces_principales(2022)


def prix_m2_dep(année):
    # Choix du dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    # Créer une table pivot pour la carte de chaleur
    pivot_df = df.pivot_table(index='Code departement', values='Prix m2', aggfunc='mean')

    # Trier le DataFrame par les prix moyens du m2
    pivot_df = pivot_df.sort_values(by='Prix m2')

    # Créer la carte de chaleur
    plt.figure(figsize=(12,8))
    sns.heatmap(pivot_df, cmap='coolwarm')
    plt.title('Prix moyen du m2 par département')
    plt.show()

prix_m2_dep(2022)


def prix_m2_dep(année):
    # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    # Calculer la moyenne des prix du m2 par département
    moyenne_prix_m2_par_departement = df.groupby('Code departement')['Prix m2'].mean().reset_index()

    # Load GeoJSON data for departments
    url_departements_geojson = 'https://france-geojson.gregoiredavid.fr/repo/departements.geojson'
    departements_geojson = json.loads(requests.get(url_departements_geojson).text)

    # Create a map centered on France
    map = folium.Map(location=[46.603354, 1.888334], zoom_start=6)

    # Create a Choropleth with average prices by department
    folium.Choropleth(
        geo_data=departements_geojson,
        name='choropleth',
        data=moyenne_prix_m2_par_departement,
        columns=['Code departement', 'Prix m2'],
        key_on='feature.properties.code',
        fill_color='Blues',
        fill_opacity=0.7,
        line_opacity=0.8,
        legend_name=f'Prix moyen du m2 par département en {année}',
        title='Prix moyen du m2 par département'
    ).add_to(map)

    # Add an info layer on hover
    info_layer = folium.GeoJson(
        departements_geojson,
        style_function=lambda x: {'fillColor': '#ffffff', 'color': '#000000', 'fillOpacity': 0.1, 'weight': 0.1},
        tooltip=folium.GeoJsonTooltip(fields=['nom', 'code'],
                                      aliases=['Département :', 'Code :'],
                                      labels=True,
                                      sticky=False),
        highlight_function=lambda x: {'weight': 3, 'fillOpacity': 0.6}
    ).add_to(map)

    # Display the map
    display(map)
    map.save(f"C:\\Users\\Jules\\Documents\\1_Cours\\ESILV\\A3\\S2\\Python\\TD8_9\\affichage\\affichage\\templates\\prixm2_par_departement_{année}.html")

prix_m2_dep(2022)


def prix_m2_région(année):
    # Choisissez le dataframe en fonction de l'année
    if année == 2018:
        df = df18
    elif année == 2019:
        df = df19
    elif année == 2020:
        df = df20
    elif année == 2021:
        df = df21
    else:
        df = df22

    # Calculer la moyenne des prix du m2 par département
    moyenne_prix_m2_par_region = df.groupby('Code region')['Prix m2'].mean().reset_index()

    # Load GeoJSON data for departments
    url_region_geojson = 'https://raw.githubusercontent.com/gregoiredavid/france-geojson/master/regions-version-simplifiee.geojson'
    region_geojson = json.loads(requests.get(url_region_geojson).text)

    # Create a map centered on France
    map = folium.Map(location=[46.603354, 1.888334], zoom_start=6)

    folium.Choropleth(
        geo_data=region_geojson,
        name='choropleth',
        data=moyenne_prix_m2_par_region,
        columns=['Code region', 'Prix m2'],
        key_on='feature.properties.code',
        fill_color='Blues',
        fill_opacity=0.7,
        line_opacity=0.8,
        legend_name=f'Prix moyen du m2 par region en {année}',
        title='Prix moyen du m2 par region'
    ).add_to(map)

    info_layer = folium.GeoJson(
        region_geojson,
        style_function=lambda x: {'fillColor': '#ffffff', 'color': '#000000', 'fillOpacity': 0.1, 'weight': 0.1},
        tooltip=folium.GeoJsonTooltip(fields=['nom', 'code'],
                                      aliases=['Région :', 'Code :'],
                                      labels=True,
                                      sticky=False),
        highlight_function=lambda x: {'weight': 3, 'fillOpacity': 0.6}
    ).add_to(map)

    # Display the map
    display(map)
    map.save(f"C:\\Users\\Jules\\Documents\\1_Cours\\ESILV\\A3\\S2\\Python\\TD8_9\\affichage\\affichage\\templates\\prixm2_par_Région_{année}.html")

prix_m2_région(2022)


df_list = [df18, df19, df20, df21, df22]
# Créer un dataframe contenant la valeur foncière moyenne pour chaque année
mean_value = [df['Valeur fonciere'].mean() for df in df_list]
année = range(2018, 2023)
df_mean_value = pd.DataFrame({'Année': année, 'Valeur foncière moyenne': mean_value})

# Créer la ligne de temps
plt.figure(figsize=(10, 6))
plt.plot(df_mean_value['Année'], df_mean_value['Valeur foncière moyenne'])
plt.xlabel('Année')
plt.ylabel('Valeur foncière moyenne')
plt.title('Changement de la valeur foncière moyenne au fil du temps')
plt.grid(True)
plt.show()


# Créer un dataframe contenant le nombre de transactions par nature de la mutation pour chaque année
df_nature = pd.concat([df['Nature mutation'].value_counts().rename(year) for df, year in zip(df_list, année)], axis=1)

# Créer le diagramme à barres empilées
df_nature.T.plot(kind='bar', stacked=True, figsize=(10, 6))
plt.xlabel('Année')
plt.ylabel('Nombre de transactions')
plt.title('Nombre de transactions par nature de la mutation par année')
plt.show()


def plot_mean_surface_reelle(année, df_list):
    mean_surfaces = []
    for df in df_list:
        mean_surfaces.append(df['Surface reelle bati'].mean())

    plt.bar(année, mean_surfaces)
    plt.xlabel('Années')
    plt.ylabel('Surface réelle bâti moyenne')
    plt.title('Évolution de la surface réelle bâti moyenne au fil du temps')
    plt.show()

plot_mean_surface_reelle(année, df_list)


def plot_heatmap_departement(année, df_list):
    departement_values = []
    for df in df_list:
        mean_values = df.groupby('Nom departement')['Valeur fonciere'].mean()
        departement_values.append(mean_values)

    df_departement_values = pd.DataFrame(departement_values, index=année).transpose()

    # Calculer la valeur moyenne sur toutes les années pour chaque département
    mean_over_année = df_departement_values.mean(axis=1)

    # Tri du DataFrame en fonction de cette moyenne
    df_departement_values_sorted = df_departement_values.loc[mean_over_année.sort_values(ascending=False).index]

    sns.heatmap(df_departement_values_sorted, cmap='YlGnBu')
    plt.title('Valeur foncière moyenne par département au fil du temps')
    plt.show()

plot_heatmap_departement(année, df_list)


def plot_heatmap_departement(année, df_list):
    departement_values = []
    for df in df_list:
        mean_values = df.groupby('Nom departement')['Valeur fonciere'].mean()
        departement_values.append(mean_values)

    df_departement_values = pd.DataFrame(departement_values, index=année).transpose()

    # Calculer la valeur moyenne sur toutes les années pour chaque département
    mean_over_année = df_departement_values.mean(axis=1)

    # Tri du DataFrame en fonction de cette moyenne
    df_departement_values_sorted = df_departement_values.loc[mean_over_année.sort_values(ascending=False).index]

    # Prendre seulement les 20 premières lignes (Top 20 des départements)
    df_departement_values_sorted = df_departement_values_sorted.head(20)

    sns.heatmap(df_departement_values_sorted, cmap='YlGnBu')
    plt.title('Valeur foncière moyenne par département au fil du temps (Top 20)')
    plt.show()

plot_heatmap_departement(année, df_list)


def plot_heatmap_region(année, df_list):
    region_values = []
    for df in df_list:
        mean_values = df.groupby('Nom region')['Valeur fonciere'].mean()
        region_values.append(mean_values)

    df_region_values = pd.DataFrame(region_values, index=année).transpose()

    # Calculer la valeur moyenne sur toutes les années pour chaque région
    mean_over_année = df_region_values.mean(axis=1)

    # Tri du DataFrame en fonction de cette moyenne
    df_region_values_sorted = df_region_values.loc[mean_over_année.sort_values(ascending=False).index]

    sns.heatmap(df_region_values_sorted, cmap='YlGnBu')
    plt.title('Valeur foncière moyenne par région au fil du temps')
    plt.show()

plot_heatmap_region(année, df_list)


years = [18, 19, 20, 21, 22]
année  = []
average_price_per_m2 = []

for year in years:
    df = globals()['df' + str(year)]
    average_price_per_m2.append(df['Prix m2'].mean())
    année.append('20'+str(year))

plt.plot(année, average_price_per_m2)
plt.xlabel('Année')
plt.ylabel('Prix moyen au mètre carré')
plt.title('Évolution du prix moyen au mètre carré par année')
plt.grid(True)
plt.show()


transaction_counts = []

for year in years:
    df = globals()['df' + str(year)]
    transaction_counts.append(df.shape[0])

plt.bar(years, transaction_counts)
plt.xlabel('Année')
plt.ylabel('Nombre de transactions')
plt.title('Comparaison du nombre de transactions par année')
plt.grid(True)
plt.show()


# Créer un dictionnaire pour stocker les valeurs totales pour chaque région et chaque année
total_values_by_region = {}
année = 2018
for df in df_list:
    total_values_by_region[année] = df.groupby('Nom region')['Valeur fonciere'].sum()
    année += 1

# Créer un dataframe à partir du dictionnaire
df_total_values_by_region = pd.DataFrame(total_values_by_region)

# Transposer le dataframe pour avoir les années en colonnes et les régions en index
df_total_values_by_region = df_total_values_by_region.transpose()

# Créer le graphique
df_total_values_by_region.plot(kind='bar', stacked=True, figsize=(10, 6))
plt.xlabel('Années')
plt.ylabel('Valeur foncière totale')
plt.title('Valeur foncière totale par région et par année')
plt.grid(True)
plt.legend(title='Région', bbox_to_anchor=(1.05, 1), loc='upper left')
plt.show()


counts_by_type = {}
df_list = [df18, df19, df20, df21, df22]
current_année = 2018
for df in df_list :
    counts_by_type[current_année] = df['Type local'].value_counts()
    current_année += 1  # Change 'année' to 'current_année'

# Créer un dataframe à partir du dictionnaire
df_counts_by_type = pd.DataFrame(counts_by_type)

# Créer le graphique
df_counts_by_type.plot(kind='bar', figsize=(10, 6))
plt.xlabel('Type de bien')
plt.ylabel('Nombre de transactions')
plt.title('Nombre de différents types de biens vendus par année')
plt.grid(False)
plt.legend(title='Année')
plt.show()

	Colonne	Libellé	Descriptif
0	1	Code service
1	2	Référence document
2	3	Article CGI 1
3	4	Article CGI 2
4	5	Article CGI 3
5	6	Article CGI 4
6	7	Article CGI 5
7	8	N°de disposition	Dans le cas des actes comprenant plusieurs mut...
8	9	Date de mutation	Date de signature de l’acte (au format JJ/MM/A...
9	10	Nature de la mutation	Vente, vente en l’état futur d’achèvement, ven...
0	11	Valeur foncière	Il s’agit du montant ou de l’évaluation déclar...
1	12	N° de voie	Numéro dans la voie
2	13	B/T/Q	Indice de répétition
3	14	Type de voie	Exemple : Rue, avenue, etc.
4	15	Code voie	Code Rivoli (répertoire informatisé codifiant,...
5	16	Voie	Libellé de la voie
6	17	Code postal
7	18	Commune	Libellé de la commune
8	19	Code département	Référence cadastrale de la parcelle
9	20	Code commune	Référence cadastrale de la parcelle
10	21	Préfixe de section
11	22	Section
12	23	N° de plan
13	24	N° de volume
14	25	1er lot	Un lot de copropriété est constitué d’une part...
15	26	Surface Carrez du 1er lot	idem
16	27	2e lot	idem
17	28	Surface Carrez du 2e lot	idem
18	29	3e lot	idem
19	30	Surface Carrez du 3e lot	idem
20	31	4e lot	idem
21	32	Surface Carrez du 4e lot	idem
22	33	5e lot	idem
23	34	Surface Carrez du 5e lot	idem
24	35	Nombre de lots	Nombre total de lots par disposition.
25	36	Code type local	1 : maison ; 2 : appartement ; 3 : dépendance ...
26	37	Type local	1 : maison ; 2 : appartement ; 3 : dépendance ...
27	38	Identifiant local	Donnée non restituée en application du décret ...
28	39	Surface réelle bâti	la surface réelle est la surface mesurée au so...
29	40	Nombre de pièces principales	les cuisines, salles d’eau et dépendances ne s...
30	41	Code nature culture	Voir dans le présente document la table de réf...
31	42	Nature culture spéciale	Voir dans le présent document la table de réfé...
32	43	Surface terrain	Contenance du terrain

Etude des demandes de valeurs foncières¶